home *** CD-ROM | disk | FTP | other *** search
/ Amiga Collections: Franz PD / Franz PD Disk #324 (1994-04)(Rhein-Sieg-Soft).zip / Franz PD Disk #324 (1994-04)(Rhein-Sieg-Soft).adf / VideoText3.5 / source / pagelist.p < prev    next >
Text File  |  1994-04-01  |  6KB  |  168 lines
  1. UNIT pagelist; {$project vt}
  2. { Verwaltung der verketteten Seitenliste zum Programm VideoText }
  3.  
  4. INTERFACE; FROM vt USES global;
  5.  
  6. PROCEDURE kill_list;
  7. PROCEDURE del_from_list(VAR target: p_onepage);
  8. FUNCTION hunt_in_list(pg,sp: Integer; exact: Boolean): p_onepage;
  9. PROCEDURE ins_to_list(item: p_onepage);
  10. PROCEDURE add_to_list(item: p_onepage);
  11. FUNCTION next_magazine(item: p_onepage): p_onepage;
  12. FUNCTION prev_magazine(item: p_onepage): p_onepage;
  13.  
  14. { ---------------------------------------------------------------------- }
  15.  
  16. IMPLEMENTATION;
  17. {$opt b-}
  18.  
  19. PROCEDURE kill_list;
  20. { Alle Seiten wegwerfen. }
  21. VAR hilf: p_onepage;
  22. BEGIN
  23.   hilf := root;
  24.   WHILE root<>Nil DO BEGIN
  25.     root := root^.next;
  26.     Dispose(hilf);
  27.     hilf := root;
  28.   END;
  29. END;
  30.  
  31. PROCEDURE del_from_list{(VAR target: p_onepage)};
  32. { Die bezeichnete Seite aus der Liste wegwerfen. Der übergebene Zeiger wird }
  33. { anschließend wieder auf einen sinnvollen Inhalt gesetzt: }
  34. {  - auf den Nachfolger der gelöschten Seite, falls sie einen hat, sonst }
  35. {  - auf ihren Vorgänger (d. h. Listenende oder Nil) }
  36. VAR hilf: p_onepage;
  37. BEGIN
  38.   IF target^.prev<>Nil THEN
  39.     target^.prev^.next := target^.next  ELSE  root := target^.next;
  40.   IF target^.next<>Nil THEN
  41.     target^.next^.prev := target^.prev;
  42.   hilf := target;
  43.   target := hilf^.next;
  44.   IF target = Nil THEN target := hilf^.prev;
  45.   Dispose(hilf);
  46. END;
  47.  
  48. FUNCTION hunt_in_list{(pg,sp: Integer; exact: Boolean): p_onepage};
  49. { Liefert einen Zeiger auf die durch <pg>, <sp> beschriebene Seite in der }
  50. { Liste. Falls eine entsprechende Seite nicht gefunden wird, ist das }
  51. { Resultat für exact=false der nächsthöhere existierende Eintrag (bzw. das }
  52. { Listenende, wenn es keinen höheren Eintrag gibt), für exact=true einfach }
  53. { Nil. Letztere Variante funktioniert dafür auch auf unsortierten Listen, }
  54. { d. h. solchen, die mit add_to_list() statt ins_to_list() aufgebaut wurden. }
  55. VAR hilf: p_onepage;
  56. BEGIN
  57.   hilf := root;
  58.   IF hilf<>Nil THEN
  59.     IF exact THEN BEGIN
  60.       { richtige Seitennummer finden }
  61.       WHILE ((hilf^.pg<>pg) OR (hilf^.sp<>sp)) AND (hilf^.next<>Nil) DO
  62.         hilf := hilf^.next;
  63.       IF ((hilf^.pg<>pg) OR (hilf^.sp<>sp)) THEN
  64.         hilf := Nil; {=hilf^.next}
  65.     END ELSE BEGIN
  66.       { richtige oder nächsthöhere Seitennummer finden }
  67.       WHILE (hilf^.pg<pg) AND (hilf^.next<>Nil) DO
  68.         hilf := hilf^.next;
  69.       { Wenn die Seitennummer stimmt, noch die Unterseite finden }
  70.       WHILE (hilf^.pg=pg) AND (hilf^.sp<sp) AND (hilf^.next<>Nil) DO
  71.         hilf := hilf^.next;
  72.     END;
  73.   hunt_in_list := hilf;
  74. END;
  75.  
  76. PROCEDURE ins_to_list{(item: p_onepage)};
  77. { Neue Seite nach Seiten- und Unterseitennummer in die Liste einsortieren. }
  78. { Es wird *nicht* überprüft, ob bereits ein gleichartiger Eintrag existiert. }
  79. { Denn das Überschreiben eines veralteten Seiteninhalts sollte sich auch auf }
  80. { andere Weise ausführen lassen, als daß New() und Dispose() direkt }
  81. { nacheinander aufgerufen werden müssen - Äh! }
  82. VAR hilf: p_onepage;
  83. BEGIN
  84.   IF root=Nil THEN BEGIN
  85.     root := item
  86.     item^.next := Nil;
  87.     item^.prev := Nil;
  88.   END ELSE BEGIN
  89.     hilf := hunt_in_list(item^.pg,item^.sp,false);
  90.     { hilf zeigt jetzt auf die Seite, vor der eingefügt werden sollte, bzw. }
  91.     { auf das Listenende, falls die neue Seite die höchste aller Nummern hat. }
  92.     IF (hilf^.pg>item^.pg) OR ((hilf^.pg=item^.pg) AND (hilf^.sp>item^.sp))
  93.     THEN BEGIN    { Normalfall, vor hilf einfügen }
  94.       item^.prev := hilf^.prev;
  95.       item^.next := hilf;
  96.       IF hilf^.prev<>Nil THEN hilf^.prev^.next := item  ELSE  root := item;
  97.       hilf^.prev := item;
  98.     END ELSE BEGIN    { Sonderfall, hinter hilf anhängen }
  99.       item^.prev := hilf;
  100.       item^.next := hilf^.next;
  101.       IF hilf^.next<>Nil THEN hilf^.next^.prev := item;
  102.       hilf^.next := item;
  103.     END;
  104.   END;
  105. END;
  106.  
  107. PROCEDURE add_to_list{(item: p_onepage)};
  108. { Hängt eine Seite ans Ende der Liste an. }
  109. VAR hilf: p_onepage;
  110. BEGIN
  111.   IF root=Nil THEN BEGIN
  112.     root := item
  113.     item^.next := Nil;
  114.     item^.prev := Nil;
  115.   END ELSE BEGIN
  116.     hilf := root;
  117.     WHILE hilf^.next<>Nil DO
  118.       hilf := hilf^.next;
  119.     { Hinter hilf anhängen: }
  120.     hilf^.next := item;
  121.     item^.prev := hilf;
  122.     item^.next := Nil;
  123.   END;
  124. END;
  125.  
  126. FUNCTION next_magazine{(item: p_onepage): p_onepage};
  127. { Erste Seite finden, die hinter <item> in der Liste steht und eine andere }
  128. { Magazinnummer trägt. Absichtlich so vorsichtig formuliert, damit das auch }
  129. { auf unsortierten Listen sinnvolle Resultate liefert. }
  130. VAR mag: integer;
  131. BEGIN
  132.   IF item<>Nil THEN BEGIN
  133.     mag := item^.pg DIV 100;
  134.     { zum nächsten Magazin vorrücken }
  135.     WHILE (item^.next<>Nil) AND (item^.pg DIV 100 = mag) DO
  136.       item := item^.next;
  137.   END;
  138.   next_magazine := item;
  139. END;
  140.  
  141. FUNCTION prev_magazine{(item: p_onepage): p_onepage};
  142. { Etwas komplizierter als next_magazine(), da nicht die erste Seite vor }
  143. { <item> mit einer anderen Magazinnummer gesucht ist, sondern von allen }
  144. { Seiten, die diese andere Magazinnummer tragen, die am weitesten vorne in }
  145. { der Liste stehende. }
  146. VAR mag: integer;
  147. BEGIN
  148.   IF item<>Nil THEN BEGIN
  149.     mag := item^.pg DIV 100;
  150.     { zum vorigen Magazin }
  151.     WHILE (item^.prev<>Nil) AND (item^.pg DIV 100 = mag) DO
  152.       item := item^.prev;
  153.     mag := item^.pg DIV 100;
  154.     { Anfang des gefundenen Magazins suchen }
  155.     WHILE (item^.prev<>Nil) AND (item^.pg DIV 100 = mag) DO
  156.       item := item^.prev;
  157.     { Hoppla, eins zu weit ... }
  158.     IF (item^.next<>Nil) AND (item^.pg DIV 100 <> mag) THEN
  159.       item := item^.next;
  160.   END;
  161.   prev_magazine := item;
  162. END;
  163.  
  164. BEGIN   { Intialisierungsteil }
  165.   root := Nil;
  166. END.
  167.  
  168.